FishMarket 1.0/FishMarket v1.0.iso/fishies/326-350/disk_349/med/source/med200src.zoo/med-stmod.c

C/C++ Source or Header | 1990-04-08 | 5KB | 161 lines

/* MED-stmod.c: SoundTracker 2.x module load / ST-song save functions
        by Teijo Kinnunen 1989, 1990 */
#include "med.h"
extern struct Kappale far tamakappale;
extern void __asm Korosta(register __a0 struct Gadget *,register __d0 BOOL);
extern void __asm PaivitaNaytto(register __d0 BOOL);
extern void __asm SetTempo(register __d0 UWORD);
extern UWORD soittimennum,lohkoja;
extern BOOL diskerr(),AskName();
extern struct Gadget far gadget3[];
extern struct Soitin *soitin[];
extern struct Lohko *lohko[];

BOOL STModLoader(char *name)
{
    BPTR fh;
    struct ST24Mod stsong = { 0 };
    UBYTE scntr,*cnvblk;
    long modlen,samplelen = 0,readlen;
    if(*name == '\0') return(AskName());
    if(!(fh = Open2(name,MODE_OLDFILE))) return(diskerr(0,0));
    if(AlustaKappale(TRUE)) return(diskerr(fh,"Lacking memory..."));
    NollaaVarit();
    lohkoja = 0;
    Ilmoita("Loading ST2.x-module...");
    Seek(fh,0,OFFSET_END);
    modlen = Seek(fh,0,OFFSET_BEGINNING);
    if(Read(fh,(void *)&stsong,sizeof(struct ST24Mod)) <
        sizeof(struct ST24Mod)) return(diskerr(fh,0));
    modlen -= sizeof(struct ST24Mod); /* length of the remaining part */
    for(scntr = 0; scntr < 31; scntr++) {
        samplelen += stsong.sample[scntr].length * 2;
    }
    modlen -= samplelen;
    if(modlen < 0)     return(diskerr(fh,"Not a valid module."));
    cnvblk = AllocMem(1028,MEMF_PUBLIC);
    if(!cnvblk) return(diskerr(fh,"No...MEMORY!!"));
    Ilmoita("Loading blocks...");
    while(modlen > 0) {    /* Load the song */
        if(lohkoja >= 100) break; /* too many blocks */
        if(AllocBlock(lohkoja,4)) {
            FreeMem(cnvblk,1028);
            return(diskerr(fh,"Hey, no mem for blocks."));
        }
        lohkoja++;
        if(modlen > 1024) readlen = 1024;
        else { readlen = modlen; memset((void *)cnvblk,0,1028); }
        if(Read(fh,cnvblk+4,readlen) < readlen) {
            FreeMem(cnvblk,1028);
            return(diskerr(fh,0));
        }
        modlen -= readlen;
        ConvertTo200(cnvblk,lohko[lohkoja-1]);
    }
    FreeMem(cnvblk,1028);
    tamakappale.lohkoja = lohkoja;
    tamakappale.tempo = 6;
    tamakappale.kappaleen_pituus = stsong.songlen;
    tamakappale.vaihtoja = 5;
    memcpy((char *)(tamakappale.soittojarjestys),(char *)(stsong.
        playseq),100);
    for(scntr = 0; scntr < 31; scntr++) {
        strcpy(tamakappale.soitin[scntr+1],stsong.sample[scntr].
            name);
        tamakappale.soittimenvoimakkuus[scntr+1] = stsong.sample[
            scntr].volume;
        tamakappale.stoisto[scntr+1] = stsong.sample[scntr].repeat;
        tamakappale.stoistonpit[scntr+1] = stsong.sample[scntr].
            replen * 2;
    }
    PaivitaNaytto(TRUE);
    Korosta(&gadget3[7],TRUE); Korosta(&gadget3[8],FALSE);
    SetTempo(6);
    Ilmoita("Loading samples...");
    soittimennum = 1;
    PaivitaSoittimennimi();
    for(scntr = 0; scntr < 31; scntr++) {
        samplelen = stsong.sample[scntr].length * 2;
        if(samplelen) {
            if(NewInstrument(samplelen,soittimennum))
                return(diskerr(fh,"No memory!!"));;
            if(Read(fh,(char *)(soitin[soittimennum]) +
                sizeof(struct Soitin),samplelen) <
                  samplelen) return(diskerr(fh,0));
        }
        SeurSoitin();
    }
    Close(fh);
    soittimennum = 1;
    PaivitaSoittimennimi();
    TulostaLohkoJaSoitin();
    Ilmoita("Module is now loaded.");
    return(FALSE);
}

void ConvertToST(UBYTE *from,UBYTE *to)
{
    extern UWORD periodit[];
    register UWORD cnt,per;
    register UBYTE instrG_V = 0,nnum;
    for(cnt = 0; cnt < (64 * 4); cnt++) {
        nnum = *from++;
        if(nnum & 0x80) { instrG_V = 1; nnum &= 0x7f; }
        else instrG_V = 0;
        if(!nnum) per = 0;
        else per = periodit[nnum - 1];
        if(instrG_V) per |= 0x1000;
        *to++ = (UBYTE)(per >> 8);
        *to++ = (UBYTE)(per & 0xff);
        *to++ = *from++;
        *to++ = *from++;
    }
}

BOOL STSongSaver(char *name)
{
    UBYTE oldexists,scnt,*convblk;
    struct SoundTrackerKappale stsong = { 0 };
    BPTR fh;
    if(*name == '\0') return(AskName());
    if(IsHere(name)) {
        oldexists = 1;
        Ilmoita("File already exists. Continue?");
        if(!Continue()) return(TRUE);
    }
    fh = Open2(name,MODE_NEWFILE);
    if(!fh) return(diskerr(0,"Can't create the file."));
    Ilmoita("Saving ST-song.");
    strcpy(stsong.st_nimi,name);
    for(scnt = 0; scnt < 15; scnt++) {
        strcpy(stsong.st_ins[scnt].sti_nimi,tamakappale.soitin[scnt+1]);
        stsong.st_ins[scnt].sti_vol = tamakappale.
            soittimenvoimakkuus[scnt+1];
        stsong.st_ins[scnt].sti_pit = soitin[scnt+1]->length / 2;
        stsong.st_ins[scnt].sti_repeat = tamakappale.stoisto[scnt+1];
        if(tamakappale.stoistonpit[scnt+1] <= 2)
            stsong.st_ins[scnt].sti_replen = 1;
        else stsong.st_ins[scnt].sti_replen = tamakappale.stoistonpit[scnt+1] / 2;
    }
    stsong.st_kappaleen_pit = tamakappale.kappaleen_pituus;
    memcpy(stsong.st_lohkojarj,tamakappale.soittojarjestys,100);
    stsong.st_kummajainen = 0x78; /* ???????? */
    if(Write(fh,(char *)&stsong,sizeof(struct SoundTrackerKappale)) !=
        sizeof(struct SoundTrackerKappale)) return(diskerr(fh,0));
    convblk = AllocMem(1024,MEMF_PUBLIC);
    if(!convblk) return(diskerr(fh,"No memory."));
    Ilmoita("Saving blocks...");
    for(scnt = 0; scnt < lohkoja; scnt++) {
        ConvertToST(lohko[scnt]->music,convblk);
        if(Write(fh,convblk,1024) != 1024) {
            FreeMem(convblk,1024);
            return(diskerr(fh,0));
        }
    }
    FreeMem(convblk,1024);
    Close(fh);
    if(!oldexists) InsertSavedFile(name);
    Ilmoita("ST-song is now saved.");
    return(FALSE);
}